home *** CD-ROM | disk | FTP | other *** search
/ Gekkan Dennou Club 147 / Gekkan Dennou Club - 2000.8 Vol. 147 (Japan).7z / Gekkan Dennou Club - 2000.8 Vol. 147 (Japan) (Track 1).bin / tools / zmc3v078 / zmc3v078.lzh / SRCSV078.LZH / VELO.C < prev    next >
C/C++ Source or Header  |  2000-02-24  |  11KB  |  487 lines
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <string.h>
  4. #include "parsesub.h"
  5. #include "etc.h"
  6.  
  7.  
  8. #include "structs.h"
  9. #include "structs2.h"
  10. UBYTE *getSpecialVelocity(UBYTE *zms,VELOETCVAR *v);
  11. WORD setVelo0(TRKCHINF *trkdata, const int Trk,VELOETCVAR v,BYTE *relvelo,TRKINF *trkinf,
  12.                 COMMONINF *cominf,UWORD step);
  13. int setVelo(TRKCHINF *trkdata, const int Trk,TRKINF *trkinf,COMMONINF *cominf,
  14.             UWORD step, WORD *v);
  15. void vSeqLoopChk(const int Trk,TRKINF *trkinf);
  16. UBYTE *setMMLatU(UBYTE *zms,TRKCHINF *trkdata,TRKINF *trkinf,
  17.                     const BYTE target[], int mode);
  18. inline DWORD rand2(DWORD r);
  19. UBYTE *makeZmdRandVelo(UBYTE *zms,TRKCHINF *trkdata, const int Trk,
  20.                         TRKINF *trkinf,COMMONINF *cominf,
  21.                         int line,char *linebuf);
  22. int setVeloRevise(TRKINF *trkinf, const int Trk,COMMONINF *cominf,UWORD step);
  23. UBYTE *dispatchVelo(UBYTE *zms, TRKCHINF *trkdata, TRKINF *trkinf,
  24.                     COMMONINF *cominf,const BYTE target[]);
  25. UBYTE *makeVeloOffset(UBYTE *zms,TRKINF *trkinf, const BYTE target[]);
  26.  
  27. extern DWORD line;
  28. extern char *linebuf;
  29. extern LINEDATA *ld;
  30.  
  31.  
  32.  
  33. UBYTE *dispatchVelo(UBYTE *zms, TRKCHINF *trkdata, TRKINF *trkinf,
  34.                     COMMONINF *cominf,const BYTE target[])
  35.  
  36. {
  37.     DWORD line_ = line;
  38.     const LINEDATA *ld_ = ld;
  39.     char *linebuf_ = linebuf;
  40.     const char *comtbl[] = {
  41.         "level","depth","deepen","control","origin",
  42.         "reset","speed","delay","waveform","switch",
  43.         "sync","mode","phase","offset","revise",
  44.         NULL
  45.     };
  46.  
  47.     zms = skipSpc(zms);
  48.     if (*zms != '.') {                        /* [velocity] */
  49.         zms = setMMLatU(zms, trkdata, trkinf, target, 0);
  50.     } else {
  51.         DWORD tmpDWORD;
  52.         int i,trk,err;
  53.  
  54.         zms++;
  55.         for (i = 0;;i++) {
  56.             if (!comtbl[i]) {
  57.                 i = -1;
  58.                 break;
  59.             } else if (!stricmp2(zms,comtbl[i])) {
  60.                 zms += strlen(comtbl[i]);
  61.                 break;
  62.             }
  63.         }
  64.  
  65.         switch (i) {
  66.             case 13:            /* [VELOCITY.offset */
  67.                 zms = makeVeloOffset(zms,trkinf,target);
  68.             case 14:            /* [VELOCITY.revise] */
  69.                 for (trk = 0; target[trk] >= 0; trk++) {
  70.                     zms = makeZmdRandVelo(zms,trkdata,target[trk],
  71.                                             trkinf,cominf,line,linebuf);
  72.                 }
  73.                 zmserror("[velocity.revise] can use only for zmc2/zmc3.",line,linebuf,zms,4,1);
  74.                 break;
  75.             default:
  76.                 break;
  77.         }
  78.     }
  79.     return zms;
  80. }
  81.  
  82.  
  83.  
  84. UBYTE *makeVeloOffset(UBYTE *zms,TRKINF *trkinf, const BYTE target[])
  85. {
  86. /*    const char *p[] = {"on", "off", NULL};*/
  87.     DWORD mode, offset;
  88.     int err, trk;
  89.  
  90.  
  91. /*    zms = getnum4(zms, &mode, &err, p, 0);*/
  92.     zms = getnum2(zms, &offset, &err);
  93.     if (!err < 0) {
  94.         zmserror("[VELOCITY.OFFSET] format error.",line,linebuf,zms,0,1);
  95.     }
  96.  
  97.     for (trk = 0; target[trk] >= 0; trk++) {
  98.         const int Trk = target[trk];
  99.  
  100.         trkinf[Trk].veloofst = offset;
  101.     }
  102.     return zms;
  103. }
  104.  
  105.  
  106.  
  107.  
  108.  
  109. /* ===============================================
  110.      get Special Velocity from MML, if there is.
  111.    =============================================== */
  112.  
  113. UBYTE *getSpecialVelocity(UBYTE *zms,VELOETCVAR *v)
  114. {
  115.     /* v->relflg[0] = 2; */        /* 0:abs 1:rel 2:omit -1:guardian */
  116.                                 /* del v0.74 */
  117.     if (*zms == ',') {
  118.         DWORD velo;
  119.         int err;
  120.  
  121.         zms = skipSpcCr(++zms);
  122.         if (*zms == '+' || *zms == '-') {
  123.             v->relflg[0] = 1;
  124. /*
  125.         } else if (*zms == '-') {
  126.             v->relflg[0] = -1;
  127. */
  128.         }
  129.         zms = getnum2(zms, &velo, &err);
  130.         if (err < 0) {        /* no value */
  131.                             /* put error */
  132.         } else {
  133.             if (v->relflg[0] == 2) {
  134.                 v->relflg[0] = 0;
  135.             }
  136. /*
  137.             if (v->relflg[0] < 0) {
  138.                 v->relflg[0] = 1;
  139.                 v->var[0] = -velo;
  140.             } else {
  141. */
  142.                 v->var[0] = velo;
  143. /* fprintf(stderr,"(%d/%d)",v->var[0],v->relflg[0]); */
  144. /*
  145.             }
  146. */
  147.         }
  148.     }
  149.     return zms;
  150. }
  151.  
  152.  
  153. /* set special velocity */
  154. /* relvelo: 0;  default
  155.  *          1;  relative value
  156.  *         -1;  absolute value
  157.  */
  158. WORD setVelo0(TRKCHINF *trkdata, const int Trk,VELOETCVAR v,BYTE *relvelo,TRKINF *trkinf,
  159.                 COMMONINF *cominf,UWORD step)
  160. {
  161.     /* const int Trk = target[trk]; */
  162.     WORD retvelo = -1;
  163.     *relvelo = 0;        /* use default */
  164.  
  165.     /* zms = getSpecialVelocity(zms,v); */
  166.     if (v.relflg[0] != 2) {            /* special velocity is there */
  167.         BYTE *vpos = &(trkinf[Trk].velozpos);        /* calc random parameter */
  168.         const WORD rvar = trkinf[Trk].velocity[*vpos].var[1];
  169.         const DWORD r = trkinf[Trk].velou.var[1];
  170.         WORD vrvar = 0;
  171.  
  172.         if ( trkinf[Trk].velocity[*vpos].var[1] ) {        /* random? */
  173.             vrvar = rvar;
  174.         } else if (r) {
  175.             vrvar = r;
  176.         }
  177.         if (vrvar) {
  178.             vrvar = rand2(vrvar);
  179.         }
  180.         *relvelo = -1;
  181.         if (v.relflg[0] == 1) {
  182. /*
  183.             if (v.var[0] >= 0) {
  184.                 *trkdata[Trk].zmd++ = 0xDA;
  185.                 *trkdata[Trk].zmd++ = v.var[0] + vrvar;
  186. */
  187.                 retvelo = v.var[0] + vrvar;
  188. /*
  189.             } else {
  190.                 *trkdata[Trk].zmd++ = 0xDB;
  191.                 *trkdata[Trk].zmd++ = -v.var[0] + vrvar;
  192.                 retvelo = -v.var[0] + vrvar;
  193.             }
  194. */
  195.             *relvelo = 1;
  196.         } else {
  197. /*
  198.             *trkdata[Trk].zmd++ = 0xD9;
  199.             *trkdata[Trk].zmd++ = v.var[0] + vrvar;
  200. */
  201.             retvelo = v.var[0] + vrvar;
  202.             *relvelo = -1;
  203.         }
  204. /* printf("[vv=%d]",v->var); */
  205.         trkinf[Trk].spvelomode = 1;
  206.         
  207.     } else {    /* special velocity is not there */
  208.         WORD v = retvelo;
  209.         int rv = setVelo(trkdata,Trk,trkinf,cominf,step,&v);
  210.  
  211.         if (rv) {
  212.             trkinf[Trk].spvelomode = 1;
  213.             *relvelo = rv;
  214.         }
  215.         retvelo = v;
  216.     }
  217.                                     /* del 0.74 */
  218. /*
  219.     if (trkinf[Trk].veloseqsw) {
  220.         vSeqLoopChk(Trk,trkinf);
  221.     }
  222. */
  223.     return retvelo;
  224. }
  225.  
  226.  
  227.  
  228. /* =======================
  229.      set normal velocity
  230.      (velocity sequence)
  231.      return 1, if random pattern(special velocity) is used.
  232.      return 0, if no velocity sequence. *v isn't modified.
  233.    ======================= */
  234.  
  235. int setVelo(TRKCHINF *trkdata, const int Trk,TRKINF *trkinf,COMMONINF *cominf,
  236.             UWORD step,WORD *v)
  237. {
  238.     BYTE *vpos = &(trkinf[Trk].velozpos);
  239.     WORD vvar = 0;
  240.     const WORD rvar = trkinf[Trk].velocity[*vpos].var[1];
  241.     /* const BYTE vnum = trkinf[Trk].veloznum; */
  242.     const DWORD r = trkinf[Trk].velou.var[1];
  243.     int ret = 0;
  244.  
  245.     recoverSpecialVelocity(trkinf, Trk);
  246. /*
  247.     if ( trkinf[Trk].veloz[1].relflg[0] && trkinf[Trk].veloseqsw) {
  248. */
  249.     if ( trkinf[Trk].velou.relflg[0] && trkinf[Trk].veloseqsw) {
  250.                                                         /* Z  velocity */
  251.                                                         /* veloz[1].relflg[0] is set
  252.                                                          * by setVelocitySequenceMode */
  253.         int v = trkinf[Trk].velocity[*vpos].var[0] + trkinf[Trk].veloofst;
  254.         if (v > 127) {
  255.             v = 127;
  256.         } else if (v < 0) {
  257.             v = 0;
  258.         }
  259.  
  260.         if (trkinf[Trk].velocity[*vpos].var[0] != 0x80 || rvar) {
  261.             *trkdata[Trk].zmd++ = 0x93;
  262.             *trkdata[Trk].zmd++ = v;
  263.         }
  264.         ret = 0;    /* don't set '-1' */
  265.         vvar = v;
  266.         if ( rvar ) {        /* random? */
  267. /* printf("#%d",trkinf[Trk].veloz[*vpos].var[1]); */
  268.             /* vvar += rand2(rvar); */
  269.             vvar = rand2(rvar);                            /* v0.72 */
  270.             ret = 1;
  271.         }
  272.         /* *velo = vvar; */
  273.     } else if (r) {                                        /* random parameter */
  274.         vvar = rand2(r);
  275.         ret = 1;
  276.     }
  277.     if (trkinf[Trk].randvelopower) {
  278.         vvar += -setVeloRevise(trkinf,Trk,cominf,step);
  279.         ret = 1;
  280.     }
  281.  
  282.     if (ret) {
  283. /*
  284.         *trkdata[Trk].zmd++ = (vvar >= 0)? 0xDA : 0xDB;
  285.         *trkdata[Trk].zmd++ = (vvar >= 0)? vvar : -vvar;
  286. */
  287.         /* *v += vvar; */
  288.         *v = vvar;
  289.     }
  290.     /* vSeqLoopChk(Trk,trkinf); */
  291.  
  292.     return ret;
  293. }
  294.  
  295.  
  296. void vSeqLoopChk(const int Trk,TRKINF *trkinf)
  297. {
  298.     /* BYTE *vpos = &(trkinf[Trk].velozpos); */
  299.     const BYTE vnum = trkinf[Trk].veloznum;
  300.  
  301.     /* if (vnum > 0) { */
  302.     if (trkinf[Trk].velou.relflg[0]) {
  303.         if (++(trkinf[Trk].velozpos) >= vnum) {
  304.             trkinf[Trk].velozpos = 0;
  305.         }
  306.     }
  307. }
  308.  
  309. /*tenuki*/
  310. UBYTE *setMMLatU(UBYTE *zms,TRKCHINF *trkdata,TRKINF *trkinf,
  311.                     const BYTE target[], int mode)
  312. {    /* mode=0:@U   mode=1: [@VELOCITY]
  313.      * mml 'u' doesn't support
  314.      */
  315.     UBYTE *zms_ = zms;
  316.     int trk;
  317.  
  318.     for (trk = 0; target[trk] >= 0; trk++) {
  319.         const int Trk = target[trk];
  320.         BYTE rel = 0;
  321.         DWORD velo,v = trkinf[Trk].velou.var[0];
  322.         DWORD r = trkinf[Trk].velou.var[1];
  323.         DWORD rp = (r)? rand2(r) : 0;
  324.         int err;
  325.         /*    line = line_; */
  326.         /*     ld = ld_; */
  327.         zms = skipSpcCr(zms_);
  328.         if (*zms == '+') {
  329.             rel = 1;
  330.         } else if (*zms == '-') {
  331.             rel = -1;
  332.         }
  333.         zms = getnum2(zms, &velo, &err);
  334.  
  335.         zms = skipSpcCr(zms);
  336.         if (*zms == ':' && *(zms + 1) != '|') {
  337.             int err2;
  338.             zms = skipSpcCr(zms + 1);
  339.             zms = getnum2(zms, &r, &err2);
  340.             r = abs(r);
  341.             rp = (r && !err2)? rand2(r) : 0;
  342.             trkinf[Trk].velou.var[1] = r;
  343.         }
  344.         if (err < 0) {                /* only '@u' */
  345.             if (trkinf[Trk].relvelo != 0) {    /*relational value */
  346.                 v += trkinf[Trk].relvelo;
  347.             } else {                        /* absolute value */
  348.                 v = trkinf[Trk].velou.var[0];
  349.             }
  350.         } else {
  351.             if (rel || mode > 0) {
  352.                 v += velo;
  353.                 trkinf[Trk].relvelo = velo;
  354.             } else {
  355.                 v = velo;
  356.                 trkinf[Trk].relvelo = 0;
  357.             }
  358.             v += rp;
  359.             if (v > 127) {
  360.                 v = 127;
  361.             } else if (v < 0) {
  362.                 v = 0;
  363.             }
  364.             trkinf[Trk].velou.var[0] = v;
  365.         }
  366.         if (!mode) {
  367.             v += trkinf[Trk].veloofst;
  368.             if (v > 127) {
  369.                 v = 127;
  370.             } else if (v < 0) {
  371.                 v = 0;
  372.             }
  373.  
  374.             *trkdata[Trk].zmd++ = 0x93;
  375.             *trkdata[Trk].zmd++ = v;
  376.         } else {
  377.             *trkdata[Trk].zmd++ = 0x94;
  378.             *trkdata[Trk].zmd++ = velo;
  379.         }
  380.         /* trkinf[Trk].veloznum = 0; */
  381.         /* trkinf[Trk].veloz[1].relflg[0] = 0; */
  382.         setVelocitySequenceMode(trkinf,Trk,0);
  383.     }
  384.     return zms;
  385. }
  386.  
  387.  
  388.  
  389. /* ===================================
  390.      get random number: -r <= x <= r
  391.    =================================== */
  392.  
  393. inline DWORD rand2(DWORD r)
  394. {
  395.     return (rand() % (r * 2 + 1)) - r;
  396. }
  397.  
  398.  
  399.  
  400.  
  401. UBYTE *makeZmdRandVelo(UBYTE *zms,TRKCHINF *trkdata, const int Trk,
  402.                         TRKINF *trkinf,COMMONINF *cominf,
  403.                         int line,char *linebuf)
  404. {
  405.     DWORD randvelotype,randvelopower;
  406.     int err;
  407.  
  408.     zms = skipSpc(zms);
  409.     zms = getnum2(zms,&randvelotype,&err);
  410.     trkinf[Trk].randvelotype = (err)? 0 : randvelotype;
  411.  
  412.  
  413.     zms = skipSpc(zms);
  414.     if (*zms != ',') {
  415.         if (*zms != ']') {
  416.             zmserror("SYNTAX ERROR.",line,linebuf,zms,0,1);
  417.         } else {
  418.             return zms;
  419.         }
  420.     }
  421.     zms = skipSpc(zms + 1);
  422.     zms = getnum2(zms,&randvelopower,&err);
  423.     trkinf[Trk].randvelopower = (err)? 0 : randvelopower;
  424.  
  425.     zms = skipSpc(zms);
  426.     if (*zms != ']') {
  427.         zmserror("SYNTAX ERROR.",line,linebuf,zms,0,1);
  428.     }
  429.  
  430.     return zms + 1;        /* skip ] */
  431. }
  432.  
  433.  
  434.  
  435. /* ========================
  436.      returns revise value
  437.    ======================== */
  438. int setVeloRevise(TRKINF *trkinf, const int Trk,COMMONINF *cominf,UWORD step)
  439. {
  440. /*
  441. |　　　[VELOCITY.REVISE type,power] とすると、「音長が短くなれば
  442. |　　なるほどマイナス方向にベロシティをランダム補正する」ように
  443. |　　なる。powerが補正の強さ(0で補正オフ)、typeが補正曲線指定
  444. |　　(0=log曲線補正 1=線形補正1 2=線形補正2 ...)。
  445. |　　　デフォルトでは補正オフ。
  446. */
  447.     int ret = 0;
  448.     const int randvelotype = trkinf[Trk].randvelotype;
  449.  
  450.     switch(randvelotype) {
  451.         case 16:
  452.         case 24:
  453.             if (trkinf[Trk].laststep >= step * 2) {
  454.                 break;
  455.             }
  456.             /* NO BREAK */
  457.         case  0:        /* log */
  458.         case  8:
  459.             do {
  460.                 int div1,div2,temp;
  461.  
  462.                 for (div1 = 0, temp = cominf->div; temp; div1++, temp /= 2) {
  463.                 }
  464.                 for (div2 = 0, temp = step;        temp; div2++, temp /= 2) {
  465.                 }
  466.                 if ((randvelotype / 8) & 1) {
  467.                     div1 -= 2;
  468.                 }
  469.                 ret = trkinf[Trk].randvelopower * (div1 - div2);
  470.             } while (0);
  471.             break;
  472.         case 1:        /* linear1 */
  473.             ret = trkinf[Trk].randvelopower * (cominf->div / step);
  474.             break;
  475.         case 2:        /* linear2 */
  476.             ret = (cominf->div / step) / trkinf[Trk].randvelopower;
  477.             break;
  478.         default:
  479.             return 0;
  480.     }
  481.  
  482.     trkinf[Trk].laststep = step;
  483.     return ret;
  484. }
  485.  
  486.  
  487.